package com.loong.android.tools;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * 文件流读取工具类
 */
public class FileStreamReader {

    private FileInputStream fis;
    private BufferedInputStream bis;

    /**
     * 返回操作的java.io.FileInputStream对象
     */
    public FileInputStream getFileInputStream() {
        return fis;
    }

    /**
     * 返回操作的java.io.BufferedInputStream对象
     */
    public BufferedInputStream getBufferedInputStream() {
        return bis;
    }

    /**
     * 开始读文件。注意：需要先获得读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param filePath 待读取文件的路径
     */
    public void startRead(String filePath) {
        if (filePath == null || filePath.length() <= 0) return;
        File file = new File(filePath);
        if (!file.exists()) return;
        try {
             fis = new FileInputStream(file);
             bis = new BufferedInputStream(fis);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读取一个字节的文件数据
     * @return 读取失败或读到尾部，没有可读数据时返回-1
     */
    public int read() {
        if (bis == null) return -1;
        try {
            return bis.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 一次性读取一定长度的文件数据到指定的字节数组中。
     * @param bytes 写入的目标数组
     * @return 返回读取到的数据长度，如果读取失败或读取到尾部，没有数据可读，返回-1。
     */
    public int read(byte[] bytes) {
        if (bis == null || bytes == null) return -1;
        try {
            return bis.read(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 一次性从指定位置读取一定长度的文件数据到指定的字节数组中。
     * @param bytes 写入的目标数组
     * @param fromIndex 起始索引
     * @param readLength 读取的长度
     * @return 返回读取到的数据长度，如果读取失败或读取到尾部，没有数据可读，返回-1。
     */
    public int read(byte[] bytes, int fromIndex, int readLength) {
        if (bis == null || bytes == null) return -1;
        if (readLength < 0 || fromIndex < 0) return -1;
        try {
            return bis.read(bytes, fromIndex, readLength);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 结束读取文件流
     */
    public void endRead() {
        try {
            if (fis != null) fis.close();
            if (bis != null) bis.close();
            fis = null;
            bis = null;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 读写位置复位
     */
    public void reset() {
        if (bis == null) return;
        try {
            bis.reset();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 标记读取的位置，下次调用resetReadPosition时，将返回到标记的位置
     * @param index 标记的位置
     */
    public void mark(int index) {
        if (bis == null) return;
        bis.mark(index);
    }

}
